// 版权归Go作者所有。版权所有。
// 此源代码的使用受BSD样式
// 许可证的约束，该许可证可以在许可证文件中找到。

// 此文件实现类型的打印。

package types

import (
	"bytes"
	"fmt"
	"go/token"
	"unicode/utf8"
)

// 限定符控制命名包级对象在
// 调用TypeString、ObjectString和SelectionString中的打印方式。
// 
// 这三个格式化例程调用每个
// 包级对象O的限定符，如果限定符返回非空的
// 字符串p，则该对象以p.O的形式打印。
// 如果返回空字符串，则只打印对象名O。
// 
// 使用nil限定符等同于使用（*Package）。路径：
// 对象由导入路径限定，例如“encoding/json.Marshal”。
// 
type Qualifier func(*Package) string

// Relative返回完全限定
// 除pkg以外的所有包的成员的限定符。
func RelativeTo(pkg *Package) Qualifier {
	if pkg == nil {
		return nil
	}
	return func(other *Package) string {
		if pkg == other {
			return "" // 同一包装；不合格
		}
		return other.Path()
	}
}

// 如果设置了gcCompatibilityMode，类型的打印被修改为与gc编译器中某些类型的表示相匹配：
// 
// /-byte和rune失去别名，分别代表
// uint8和int32 
// /-嵌入式接口变平（嵌入信息丢失，
// 某些递归接口类型无法再打印）
// 
// 这使得比较使用-
// 类型计算的包与从gc导出数据导入的包更加容易。
// 
// 注意：此标志在全局范围内影响WriteType的所有使用。
// 它仅用于与
// gc生成的数据。
// 
// 此标志在x/tools/go/types包中导出。我们现在在std repo中不需要它，因此我们不再导出它
// 我们最终应该尝试完全删除它。
// TODO（gri）删除此
var gcCompatibilityMode bool

// TypeString返回类型的字符串表示形式。
// 限定符控制
// 包级对象的打印，可能为零。
func TypeString(typ Type, qf Qualifier) string {
	var buf bytes.Buffer
	WriteType(&buf, typ, qf)
	return buf.String()
}

// WriteType将类型的字符串表示形式写入buf。
// 限定符控制
func WriteType(buf *bytes.Buffer, typ Type, qf Qualifier) {
	writeType(buf, typ, qf, make([]Type, 0, 8))
}

// instanceMarker是“非计算”中实例化类型
// 的前缀实例形式.
const instanceMarker = '#'

func writeType(buf *bytes.Buffer, typ Type, qf Qualifier, visited []Type) {
	// 理论上，这是一个二次查找算法，但在
	// 实践中，使用未命名组件的深度嵌套复合类型
	// 类型不常见。此代码可能比使用映射的
	// 效率更高。
	for _, t := range visited {
		if t == typ {
			fmt.Fprintf(buf, "○%T", goTypeName(typ)) // 循环到类型
			return
		}
	}
	visited = append(visited, typ)

	switch t := typ.(type) {
	case nil:
		buf.WriteString("<nil>")

	case *Basic:
		// 导出的基本类型进入包不安全
		// （目前这只是不安全的.指针）
		if token.IsExported(t.name) {
			if obj, _ := Unsafe.scope.Lookup(t.name).(*TypeName); obj != nil {
				writeTypeName(buf, obj, qf)
				break
			}
		}

		if gcCompatibilityMode {
			// 忘记别名
			switch t.kind {
			case Byte:
				t = Typ[Uint8]
			case Rune:
				t = Typ[Int32]
			}
		}
		buf.WriteString(t.name)

	case *Array:
		fmt.Fprintf(buf, "[%d]", t.len)
		writeType(buf, t.elem, qf, visited)

	case *Slice:
		buf.WriteString("[]")
		writeType(buf, t.elem, qf, visited)

	case *Struct:
		buf.WriteString("struct{")
		for i, f := range t.fields {
			if i > 0 {
				buf.WriteString("; ")
			}
			// 这对嵌入类型
			// 别名不正确，我们应该打印别名，而不是
			// 别名类型（参见问题#44410）。如果参数中嵌入了
			if !f.embedded {
				buf.WriteString(f.name)
				buf.WriteByte(' ')
			}
			writeType(buf, f.typ, qf, visited)
			if tag := t.Tag(i); tag != "" {
				fmt.Fprintf(buf, " %q", tag)
			}
		}
		buf.WriteByte('}')

	case *Pointer:
		buf.WriteByte('*')
		writeType(buf, t.base, qf, visited)

	case *Tuple:
		writeTuple(buf, t, false, qf, visited)

	case *Signature:
		buf.WriteString("func")
		writeSignature(buf, t, qf, visited)

	case *_Sum:
		for i, t := range t.types {
			if i > 0 {
				buf.WriteString(", ")
			}
			writeType(buf, t, qf, visited)
		}

	case *Interface:
		// 可能具有不可打印的循环，因此我们编写的是源代码级方法和嵌入类型，而不是实际的方法集嵌入ABCFDG 
		// 接口类型（直接或间接），则
		// 
		buf.WriteString("interface{")
		empty := true
		if gcCompatibilityMode {
			// 打印平坦接口
			// （用于与gc生成的接口进行比较）
			for i, m := range t.allMethods {
				if i > 0 {
					buf.WriteString("; ")
				}
				buf.WriteString(m.name)
				writeSignature(buf, m.typ.(*Signature), qf, visited)
				empty = false
			}
			if !empty && t.allTypes != nil {
				buf.WriteString("; ")
			}
			if t.allTypes != nil {
				buf.WriteString("type ")
				writeType(buf, t.allTypes, qf, visited)
			}
		} else {
			// 打印显式接口方法和嵌入类型
			for i, m := range t.methods {
				if i > 0 {
					buf.WriteString("; ")
				}
				buf.WriteString(m.name)
				writeSignature(buf, m.typ.(*Signature), qf, visited)
				empty = false
			}
			if !empty && t.types != nil {
				buf.WriteString("; ")
			}
			if t.types != nil {
				buf.WriteString("type ")
				writeType(buf, t.types, qf, visited)
				empty = false
			}
			if !empty && len(t.embeddeds) > 0 {
				buf.WriteString("; ")
			}
			for i, typ := range t.embeddeds {
				if i > 0 {
					buf.WriteString("; ")
				}
				writeType(buf, typ, qf, visited)
				empty = false
			}
		}
		if t.allMethods == nil || len(t.methods) > len(t.allMethods) {
			if !empty {
				buf.WriteByte(' ')
			}
			buf.WriteString("/* incomplete */")
		}
		buf.WriteByte('}')

	case *Map:
		buf.WriteString("map[")
		writeType(buf, t.key, qf, visited)
		buf.WriteByte(']')
		writeType(buf, t.elem, qf, visited)

	case *Chan:
		var s string
		var parens bool
		switch t.dir {
		case SendRecv:
			s = "chan "
			// chan（<-chan T）需要括号
			if c, _ := t.elem.(*Chan); c != nil && c.dir == RecvOnly {
				parens = true
			}
		case SendOnly:
			s = "chan<- "
		case RecvOnly:
			s = "<-chan "
		default:
			panic("unreachable")
		}
		buf.WriteString(s)
		if parens {
			buf.WriteByte('(')
		}
		writeType(buf, t.elem, qf, visited)
		if parens {
			buf.WriteByte(')')
		}

	case *Named:
		writeTypeName(buf, t.obj, qf)
		if t.targs != nil {
			// 实例化类型
			buf.WriteByte('[')
			writeTypeList(buf, t.targs, qf, visited)
			buf.WriteByte(']')
		} else if t.tparams != nil {
			// 参数化类型
			writeTParamList(buf, t.tparams, qf, visited)
		}

	case *_TypeParam:
		s := "?"
		if t.obj != nil {
			s = t.obj.name
		}
		buf.WriteString(s + subscript(t.id))

	case *instance:
		buf.WriteByte(instanceMarker) // 对于类型的外部定义实现指示“未评估”语法实例
		writeTypeName(buf, t.base.obj, qf)
		buf.WriteByte('[')
		writeTypeList(buf, t.targs, qf, visited)
		buf.WriteByte(']')

	case *bottom:
		buf.WriteString("⊥")

	case *top:
		buf.WriteString("⊤")

	default:
		// 
		buf.WriteString(t.String())
	}
}

func writeTypeList(buf *bytes.Buffer, list []Type, qf Qualifier, visited []Type) {
	for i, typ := range list {
		if i > 0 {
			buf.WriteString(", ")
		}
		writeType(buf, typ, qf, visited)
	}
}

func writeTParamList(buf *bytes.Buffer, list []*TypeName, qf Qualifier, visited []Type) {
	// TODO（rFindley）将其与types2中的相应实现进行比较
	buf.WriteString("[")
	var prev Type
	for i, p := range list {
		// TODO（rFindley）在此处支持“any”sugar。
		var b Type = &emptyInterface
		if t, _ := p.typ.(*_TypeParam); t != nil && t.bound != nil {
			b = t.bound
		}
		if i > 0 {
			if b != prev {
				// 类型绑定已更改-在升级
				buf.WriteByte(' ')
				writeType(buf, prev, qf, visited)
			}
			buf.WriteString(", ")
		}
		prev = b

		if t, _ := p.typ.(*_TypeParam); t != nil {
			writeType(buf, t, qf, visited)
		} else {
			buf.WriteString(p.name)
		}
	}
	if prev != nil {
		buf.WriteByte(' ')
		writeType(buf, prev, qf, visited)
	}
	buf.WriteByte(']')
}

func writeTypeName(buf *bytes.Buffer, obj *TypeName, qf Qualifier) {
	s := "<Named w/o object>"
	if obj != nil {
		if obj.pkg != nil {
			writePackage(buf, obj.pkg, qf)
		}
		// TODO（gri）之前写入上一个：函数本地命名类型的显示方式应与包级别的命名类型不同，以避免出现歧义。
		s = obj.name
	}
	buf.WriteString(s)
}

func writeTuple(buf *bytes.Buffer, tup *Tuple, variadic bool, qf Qualifier, visited []Type) {
	buf.WriteByte('(')
	if tup != nil {
		for i, v := range tup.vars {
			if i > 0 {
				buf.WriteString(", ")
			}
			if v.name != "" {
				buf.WriteString(v.name)
				buf.WriteByte(' ')
			}
			typ := v.typ
			if variadic && i == len(tup.vars)-1 {
				if s, ok := typ.(*Slice); ok {
					buf.WriteString("...")
					typ = s.elem
				} else {
					// 特例：
					// 追加（s，“foo”…）导致签名func（[]字节，字符串…）
					if t := asBasic(typ); t == nil || t.kind != String {
						panic("internal error: string type expected")
					}
					writeType(buf, typ, qf, visited)
					buf.WriteString("...")
					continue
				}
			}
			writeType(buf, typ, qf, visited)
		}
	}
	buf.WriteByte(')')
}

// WriteSignature将签名的表示形式写入buf，
// 不带前导的“func”关键字。
// 限定符控制
// 包级对象的打印，可以为零。
func WriteSignature(buf *bytes.Buffer, sig *Signature, qf Qualifier) {
	writeSignature(buf, sig, qf, make([]Type, 0, 8))
}

func writeSignature(buf *bytes.Buffer, sig *Signature, qf Qualifier, visited []Type) {
	if sig.tparams != nil {
		writeTParamList(buf, sig.tparams, qf, visited)
	}

	writeTuple(buf, sig.params, sig.variadic, qf, visited)

	n := sig.results.Len()
	if n == 0 {
		// 无结果
		return
	}

	buf.WriteByte(' ')
	if n == 1 && sig.results.vars[0].name == "" {
		// 单个未命名结果
		writeType(buf, sig.results.vars[0].typ, qf, visited)
		return
	}

	// 多个或命名结果
	writeTuple(buf, sig.results, false, qf, visited)
}

// 下标使用下标数字返回x的十进制（utf8）表示形式。
func subscript(x uint64) string {
	const w = len("₀") // 所有数字0…9具有相同的utf8宽度
	var buf [32 * w]byte
	i := len(buf)
	for {
		i -= w
		utf8.EncodeRune(buf[i:], '₀'+rune(x%10)) // /'₀' == U+2080 
		x /= 10
		if x == 0 {
			break
		}
	}
	return string(buf[i:])
}
